/*
Copyright (C) 1996-1997 Id Software, Inc.

This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License
as published by the Free Software Foundation; either version 3
of the License, or (at your option) any later version.

This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.

See the GNU General Public License for more details.

You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA  02111-1307, USA.

*/
// host.c -- coordinates spawning and killing of local servers

#include "quakedef.h"

/*

A server can allways be started, even if the system started out as a client
to a remote system.

A client can NOT be started if the system started as a dedicated server.

Memory is cleared / released when a server or client begins, not when they end.

*/

quakeparms_t host_parms;

BOOL	host_initialized;		// TRUE if into command execution

double		realtime;				// without any filtering or bounding
int			host_framecount;

client_t	*host_client;			// current client

jmp_buf 	host_abortserver;

cvar_t *host_maxfps;
cvar_t *host_framerate;
cvar_t *host_timescale;
cvar_t *fraglimit;
cvar_t *timelimit;
cvar_t *teamplay;
cvar_t *samelevel;
cvar_t *noexit;
cvar_t *developer;
cvar_t *skill;
cvar_t *deathmatch;
cvar_t *coop;
cvar_t *pausable;

cvar_t *temp1;
cvar_t *temp2;
cvar_t *temp3;
cvar_t *temp4;


void History_Shutdown (void);

/*
================
Host_EndGame
================
*/
void Host_EndGame (char *message, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr, message);
	vsprintf (string, message, argptr);
	va_end (argptr);
	Con_Printf (PRINT_DEVELOPER, "Host_EndGame: %s\n", string);

	if (sv.active)
		Host_ShutdownServer (FALSE);

	if (cls.demonum != -1)
		CL_NextDemo ();
	else
		CL_Disconnect ();

	longjmp (host_abortserver, 1);
}

/*
================
Host_Error

This shuts down both the client and server
================
*/
void Host_Error (char *error, ...)
{
	va_list		argptr;
	char		string[1024];
	static	BOOL inerror = FALSE;

	if (inerror)
		Sys_Error ("Host_Error: recursively entered");

	inerror = TRUE;

	SCR_EndLoadingPlaque ();		// reenable screen updates

	va_start (argptr, error);
	vsprintf (string, error, argptr);
	va_end (argptr);
	Con_Printf (PRINT_DEFAULT, "Host_Error: %s\n", string);

	if (sv.active)
		Host_ShutdownServer (FALSE);

	CL_Disconnect ();
	cls.demonum = -1;

	inerror = FALSE;

	longjmp (host_abortserver, 1);
}

/*
================
Host_FindMaxClients
================
*/
void Host_FindMaxClients (void)
{
	int		i;

	svs.maxclients = 1;
	cls.state = ca_disconnected;

	if ((i = COM_CheckParm ("-listen")) != 0)
	{
		if (i != (com_argc - 1))
			svs.maxclients = Q_atoi (com_argv[i + 1]);
		else svs.maxclients = 8;
	}

	if (svs.maxclients < 1)
		svs.maxclients = 8;
	else if (svs.maxclients > MAX_SCOREBOARD)
		svs.maxclients = MAX_SCOREBOARD;

	svs.maxclientslimit = svs.maxclients;

	if (svs.maxclientslimit < 4)
		svs.maxclientslimit = 4;

	svs.clients = (client_t *) zoneHeap->Alloc (svs.maxclientslimit * sizeof (client_t));

	if (svs.maxclients > 1)
		Cvar_SetValue (deathmatch, 1.0);
	else Cvar_SetValue (deathmatch, 0.0);
}


/*
=======================
Host_InitLocal
======================
*/
void Host_InitLocal (void)
{
	Host_InitCommands ();

	host_maxfps = Cvar_Get ("host_maxfps", "72", CVAR_ARCHIVE, Host_RearmTimers);
	host_framerate = Cvar_Get ("host_framerate", "0");
	host_timescale = Cvar_Get ("host_timescale", "0");

	fraglimit = Cvar_Get ("fraglimit", "0", CVAR_SERVER);
	timelimit = Cvar_Get ("timelimit", "0", CVAR_SERVER);

	teamplay = Cvar_Get ("teamplay", "0", CVAR_SERVER);
	samelevel = Cvar_Get ("samelevel", "0");
	noexit = Cvar_Get ("noexit", "0", CVAR_SERVER);

	developer = Cvar_Get ("developer", "0");
	skill = Cvar_Get ("skill", "1");

	deathmatch = Cvar_Get ("deathmatch", "0");
	coop = Cvar_Get ("coop", "0");
	pausable = Cvar_Get ("pausable", "1");

	temp1 = Cvar_Get ("temp1", "0");
	temp2 = Cvar_Get ("temp2", "0");
	temp3 = Cvar_Get ("temp3", "0");
	temp4 = Cvar_Get ("temp4", "0");

	Host_FindMaxClients ();
}


/*
===============
Host_WriteConfiguration

Writes key bindings and archived cvars to config.cfg
===============
*/
void Host_WriteConfiguration (void)
{
	// dedicated servers initialize the host but don't parse and set the config.cfg cvars
	if (host_initialized)
	{
		FILE *f = fopen (va ("%s/config.cfg", com_gamedir), "w");

		if (!f)
		{
			Con_Printf (PRINT_SAFE, "Couldn't write config.cfg\n");
			return;
		}

		Key_WriteBindings (f);
		Cvar_WriteVariables (f);

		fclose (f);
		Con_Printf (PRINT_SAFE, "Wrote config.cfg\n");
	}
}


/*
=================
SV_ClientPrintf

Sends text across to be displayed
FIXME: make this just a stuffed echo?
=================
*/
void SV_ClientPrintf (char *fmt, ...)
{
	va_list	argptr;
	char *string = NULL;
	QSCRATCHLOCKER Lock ((void **) &string, __FUNCTION__);

	va_start (argptr, fmt);
	vsprintf (string, fmt, argptr);
	va_end (argptr);

	MSG_WriteByte (&host_client->message, svc_print);
	MSG_WriteString (&host_client->message, string);
}

/*
=================
SV_BroadcastPrintf

Sends text to all active clients
=================
*/
void SV_BroadcastPrintf (char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];
	int			i;

	va_start (argptr, fmt);
	vsprintf (string, fmt, argptr);
	va_end (argptr);

	for (i = 0; i < svs.maxclients; i++)
	{
		if (svs.clients[i].active && svs.clients[i].spawned)
		{
			MSG_WriteByte (&svs.clients[i].message, svc_print);
			MSG_WriteString (&svs.clients[i].message, string);
		}
	}
}

/*
=================
Host_ClientCommands

Send text over to the client to be executed
=================
*/
void Host_ClientCommands (char *fmt, ...)
{
	va_list		argptr;
	char		string[1024];

	va_start (argptr, fmt);
	vsprintf (string, fmt, argptr);
	va_end (argptr);

	MSG_WriteByte (&host_client->message, svc_stufftext);
	MSG_WriteString (&host_client->message, string);
}

/*
=====================
SV_DropClient

Called when the player is getting totally kicked off the host
if (crash = TRUE), don't bother sending signofs
=====================
*/
void SV_DropClient (BOOL crash)
{
	int		saveSelf;
	int		i;
	client_t *client;

	if (!crash)
	{
		// send any final messages (don't check for errors)
		if (NET_CanSendMessage (host_client->netconnection))
		{
			MSG_WriteByte (&host_client->message, svc_disconnect);
			NET_SendMessage (host_client->netconnection, &host_client->message);
		}

		if (host_client->edict && host_client->spawned)
		{
			// call the prog function for removing a client
			// this will set the body to a dead frame, among other things
			saveSelf = pr_env.globalStruct->self;
			PR_RunInteraction (pr_env.globalStruct->ClientDisconnect, host_client->edict, NULL, sv.time);
			pr_env.globalStruct->self = saveSelf;
		}
	}

	// break the net connection
	NET_Close (host_client->netconnection);
	host_client->netconnection = NULL;

	// free the client (the body stays around)
	host_client->active = FALSE;
	host_client->name[0] = 0;
	host_client->old_frags = -999999;
	net_activeconnections--;

	// send notification to all clients
	for (i = 0, client = svs.clients; i < svs.maxclients; i++, client++)
	{
		if (!client->active)
			continue;

		MSG_WriteByte (&client->message, svc_updatename);
		MSG_WriteByte (&client->message, host_client - svs.clients);
		MSG_WriteString (&client->message, "");
		MSG_WriteByte (&client->message, svc_updatefrags);
		MSG_WriteByte (&client->message, host_client - svs.clients);
		MSG_WriteShort (&client->message, 0);
		MSG_WriteByte (&client->message, svc_updatecolors);
		MSG_WriteByte (&client->message, host_client - svs.clients);
		MSG_WriteByte (&client->message, 0);
	}
}

/*
==================
Host_ShutdownServer

This only happens at the end of a game, not between levels
==================
*/
void Host_ShutdownServer (BOOL crash)
{
	int		i;
	int		count;
	sizebuf_t	buf;
	char		message[4];
	double	start;

	if (!sv.active)
		return;

	sv.active = FALSE;

	// stop all client sounds immediately
	if (cls.state == ca_connected)
		CL_Disconnect ();

	// flush any pending messages - like the score!!!
	start = Sys_DoubleTime ();

	do
	{
		count = 0;

		for (i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++)
		{
			if (host_client->active && host_client->message.cursize)
			{
				if (NET_CanSendMessage (host_client->netconnection))
				{
					NET_SendMessage (host_client->netconnection, &host_client->message);
					SZ_Clear (&host_client->message);
				}
				else
				{
					NET_GetMessage (host_client->netconnection);
					count++;
				}
			}
		}

		if ((Sys_DoubleTime () - start) > 3.0)
			break;
	} while (count);

	// make sure all the clients know we're disconnecting
	buf.data = (byte *) message;
	buf.maxsize = 4;
	buf.cursize = 0;
	MSG_WriteByte (&buf, svc_disconnect);
	count = NET_SendToAll (&buf, 5);

	if (count)
		Con_Printf (PRINT_DEFAULT, "Host_ShutdownServer: NET_SendToAll failed for %u clients\n", count);

	for (i = 0, host_client = svs.clients; i < svs.maxclients; i++, host_client++)
		if (host_client->active)
			SV_DropClient (crash);

	// clear structures
	memset (&sv, 0, sizeof (sv));
	memset (svs.clients, 0, svs.maxclientslimit * sizeof (client_t));
}


/*
================
Host_ClearMemory

This clears all the memory used by both the client and server, but does
not reinitialize anything.
================
*/
void Host_ClearMemory (void)
{
	Mod_ClearAll ();

	// everything allocated per-map must be freed
	mapPool->FreeToLowMark (0);

	cls.signon = 0;

	memset (&sv, 0, sizeof (sv));
	memset (&cl, 0, sizeof (cl));
}


//============================================================================

// timer objects should only ever be accessed from here
class hosttimer_t
{
private:
	double		lastframe;
	double		nextframe;

public:
	void Rearm (void)
	{
		this->lastframe = realtime;
		this->nextframe = realtime + HOST_FRAMEDELTA;
	}

	BOOL RunFrame (void)
	{
		// always run a frame if in a timedemo, otherwise only run one if the time for the next frame has arrived
		if (cls.timedemo)
			return TRUE;
		else return (realtime >= this->nextframe);
	}

	double Adjust (double maxfps)
	{
		double delta = 0.0;

		// get current frametime
		double frametime = realtime - this->lastframe;

		// evaluate delta - timedemos always run but must accumulate a delta otherwise the times will be off when they finish
		if (cls.timedemo)
			delta = HOST_FRAMEDELTA;
		else if (key_dest != key_game || cls.signon != SIGNONS)
			delta = HOST_FRAMEDELTA;
		else
		{
			if (maxfps > 0.0)
				delta = (1.0 / maxfps);
			else delta = 0;

			// adjust if desired
			if (host_framerate->value > 0) frametime = host_framerate->value;
			if (host_timescale->value > 0) frametime *= host_timescale->value;
		}

		// don't allow really long frames or really long deltas
		if (frametime > 0.1) frametime = 0.1;
		if (delta > 0.1) delta = 0.1;

		// bring on the times for the next frame
		this->lastframe = realtime;
		this->nextframe += delta;

		return frametime;
	}
};


static hosttimer_t sv_timer;
static hosttimer_t cl_timer;


void Host_RearmTimers (void)
{
	// get a new realtime because the action which caused the rearm may have taken some time
	realtime = Sys_DoubleTime ();

	// if host_maxfps changes then reset the timers and deltas so that we don't get bad accumulation
	cl_timer.Rearm ();
	sv_timer.Rearm ();
}


void Host_ServerFrame (void)
{
	// bring the server timer up to date
	double frametime = sv_timer.Adjust (HOST_STANDARDFPS);

	// some of these are really client actions but they must be synchronized with the server so we do them here
	// process console commands
	Cbuf_Execute ();

	NET_Poll ();
	CL_SendCmd (frametime);

	// and how we're on to the real server actions
	if (sv.active)
	{
		pr_env.globalStruct->frametime = frametime;

		SV_ClearDatagram ();
		SV_CheckForNewClients ();
		SV_RunClients (frametime);

		// move things around and think
		// always pause in single player if in console or menus
		if (!sv.paused && (svs.maxclients > 1 || key_dest == key_game))
			SV_Physics (frametime);

		SV_SendClientMessages ();
	}
}


void Host_ClientFrame (void)
{
	// bring the client timer up to date
	double frametime = cl_timer.Adjust (host_maxfps->value);

	// fetch results from server
	if (cls.state == ca_connected)
		CL_ReadFromServer (frametime);

	// bring the mouse state up to date
	IN_Frame ();

	// update the screen
	SCR_UpdateScreen (frametime);

	// update audio
	if (cls.signon == SIGNONS)
		S_Update (frametime, ref.ViewOrigin, ref.ViewMatrix.Forward (), ref.ViewMatrix.Right (), ref.ViewMatrix.Up ());
	else S_Update (frametime, vec3_origin, vec3_origin, vec3_origin, vec3_origin);

	CDAudio_Update ();
}


/*
==================
Host_Frame

Runs all active servers
==================
*/
void Host_Frame (void)
{
	// this pool is fully wiped each frame
	qScratch->FreeToLowMark (0);

	// something bad happened, or the server disconnected
	if (setjmp (host_abortserver))
	{
		// also reset the timers and deltas here
		Host_RearmTimers ();
		return;
	}

	// keep the random time dependent
	rand ();

	// advance real time
	realtime = Sys_DoubleTime ();

	// get new key events
	Sys_SendKeyEvents ();

	// if a server frame runs we must also run a client frame to get the results immediately; otherwise
	// we only run a client frame if the accumulated time exceeds the delta
	if (sv_timer.RunFrame ())
	{
		Host_ServerFrame ();
		Host_ClientFrame ();
	}
	else if (cl_timer.RunFrame ())
		Host_ClientFrame ();

	// yield the processor only if we're not in a timedemo
	if (!cls.timedemo)
	{
		// use a different yielding strategy depending on whether or not we're currently in the game
		if (key_dest != key_game)
			MsgWaitForMultipleObjects (0, NULL, FALSE, 5, QS_ALLINPUT);
		else YieldProcessor ();
	}

	// this is only used for measuring in timedemos
	host_framecount++;
}


//============================================================================


/*
====================
Host_Init
====================
*/
void Host_Init (quakeparms_t *parms)
{
	// copy over parameters
	memcpy (&host_parms, parms, sizeof (quakeparms_t));

	com_argc = parms->argc;
	com_argv = parms->argv;

	// the console is initialized before anything else so we get full startup text
	Con_Init ();
	Con_Printf (PRINT_SAFE, "Exe: "__TIME__" "__DATE__"\n\n");

	Cbuf_Init ();
	Cmd_Init ();
	V_Init ();
	FS_Init (parms->basedir);
	Con_Printf (PRINT_SAFE, "\n");

	Host_InitLocal ();
	Key_Init ();
	M_Init ();
	PR_Init ();
	Mod_Init ();
	NET_Init ();
	SV_Init ();
	Con_Printf (PRINT_SAFE, "\n");

	// exec the configs early so that we can get correct cvars for initializing all of our stuff
	Cbuf_InsertText ("exec quake.rc\n");
	Cbuf_Execute ();
	Con_Printf (PRINT_SAFE, "\n");

	VID_Init ();
	Draw_Init ();
	SCR_Init ();
	R_Init ();
	S_Init ();
	CDAudio_Init ();
	Sbar_Init ();
	CL_Init ();
	IN_Init ();
	Con_Printf (PRINT_SAFE, "\n");

	// now that everything is up we can load the current game
	FS_LoadGame ();

	host_initialized = TRUE;

	// now we start the demo loop
	Host_RunDemoLoop ();
}


/*
===============
Host_Shutdown

FIXME: this is a callback from Sys_Quit and Sys_Error.  It would be better
to run quit through here before the final handoff to the sys code.
===============
*/
void Host_Shutdown (void)
{
	static BOOL isdown = FALSE;

	// preventing a recursive shutdown in case an error during shutdown calls this
	if (isdown) return;

	isdown = TRUE;

	// keep Con_Printf from trying to update the screen
	SCR_DisableForLoading (TRUE);

	Host_WriteConfiguration ();

	if (con_initialized)
		History_Shutdown ();

	CDAudio_Shutdown ();
	NET_Shutdown ();
	S_Shutdown ();
	IN_Shutdown ();

	// video comes last because sound and input depend on the HWND created by it
	VID_Shutdown ();
}

